package com.project.personal_blog.garbage_classification_management_system.Controller;

import com.project.personal_blog.garbage_classification_management_system.pojo.Code;
import com.project.personal_blog.garbage_classification_management_system.pojo.Result;
import com.project.personal_blog.garbage_classification_management_system.pojo.User;
import com.project.personal_blog.garbage_classification_management_system.service.RootService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/root")
public class RootController {
    @Autowired
    private RootService rootService;

    @DeleteMapping("/delete/all")
    public ResponseEntity<Result> deleteUsers() {
        // 尝试删除用户
        try {
            boolean result = rootService.deleteUsers();
            Result result1;
            // 如果删除失败，返回用户不存在
            if (!result) {
                result1 = new Result("用户不存在,无法清空", Code.DELETE_FAIL, false);
            } else {
                // 如果删除成功，返回清空成功
                result1 = new Result("清空成功", Code.DELETE_SUCCESS);
            }
            // 返回结果
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 如果发生异常，抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @GetMapping("/select/all")
    public ResponseEntity<Result> selectUsers() {
        try {
            // 调用rootService的selectUsers方法，获取用户列表
            List<User> users = rootService.selectUsers();
            Result result;
            // 如果用户列表为空，返回一个错误或空的结果
            if (users.isEmpty()) {
                result = new Result("没有找到用户", Code.SELECT_FAIL);
            } else {
                // 如果用户列表不为空，返回成功的结果，并包含用户列表数据
                result = new Result("查找用户成功", Code.SELECT_SUCCESS, users);
            }
            // 返回成功的结果
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            // 捕获异常，并抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @GetMapping("/select/{name}")
    public ResponseEntity<Result> selectByUsername(@PathVariable String name) {
        // 根据用户名查询用户
        try {
            User user = rootService.selectByUsername(name);
            Result result;
            if (user == null) {
                // 如果用户列表为空，返回一个错误或空的结果
                result = new Result("没有找到用户", Code.SELECT_FAIL);
            } else {
                // 如果用户列表不为空，返回成功的结果，并包含用户列表数据
                result = new Result("查找用户成功", Code.SELECT_SUCCESS, user);
            }
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            // 捕获异常，并抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @GetMapping("/select/{id}")
    public ResponseEntity<Result> selectById(@PathVariable Integer id) {
        // 根据id查找用户
        try {
            User user = rootService.selectById(id);
            Result result;
            if (user == null) {
                // 如果用户列表为空，返回一个错误或空的结果
                result = new Result("没有找到用户", Code.SELECT_FAIL);
            } else {
                // 如果用户列表不为空，返回成功的结果，并包含用户列表数据
                result = new Result("查找用户成功", Code.SELECT_SUCCESS, user);
            }
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            // 捕获异常，并抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @GetMapping("/select/{phoneNumber}")
    public ResponseEntity<Result> selectByPhoneNumber(@PathVariable String phoneNumber) {
        try {
            // 根据电话号码查询用户
            User user = rootService.selectByPhoneNumber(phoneNumber);
            Result result;
            if (user == null) {
                // 如果用户列表为空，返回一个错误或空的结果
                result = new Result("没有找到用户", Code.SELECT_FAIL);
            } else {
                // 如果用户列表不为空，返回成功的结果，并包含用户列表数据
                result = new Result("查找用户成功", Code.SELECT_SUCCESS, user);
            }
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            // 捕获异常，并抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @GetMapping("/select/{email}")
    public ResponseEntity<Result> selectByEmail(@PathVariable String email) {
        // 根据邮箱查询用户
        try {
            User user = rootService.selectByEmail(email);
            Result result;
            if (user == null) {
                // 如果用户列表为空，返回一个错误或空的结果
                result = new Result("没有找到用户", Code.SELECT_FAIL);
            } else {
                // 如果用户列表不为空，返回成功的结果，并包含用户列表数据
                result = new Result("查找用户成功", Code.SELECT_SUCCESS, user);
            }
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            // 捕获异常，并抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    // 定义一个@PostMapping注解，表示此方法用于处理HTTP POST请求，请求的URL为"/add"
    @PostMapping("/add")
    public ResponseEntity<Result> addUser(@RequestBody User userValue) {
        try {
            // 调用rootService的addUser方法，将userValue作为参数传入，将返回值赋值给user
            User user = rootService.addUser(userValue);
            // 定义一个Result对象，用于返回结果
            Result result;
            // 如果user为空，表示用户列表为空，返回一个错误或空的结果
            if (user == null) {
                result = new Result("已经有此用户存在,无法添加", Code.ADD_FAIL);
            } else {
                // 如果user不为空，表示用户列表不为空，返回成功的结果，并包含用户列表数据
                result = new Result("添加用户成功", Code.ADD_SUCCESS, user);
            }
            // 返回一个ResponseEntity对象，包含结果对象
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            // 抛出一个运行时异常
            throw new RuntimeException(e);
        }
    }

    // 根据id删除用户
    @DeleteMapping("/delete/{id}")
    public ResponseEntity<Result> deleteUser(@PathVariable Integer id) {
        try {
            // 调用rootService的deleteUser方法，根据id删除用户
            boolean result = rootService.deleteUser(id);
            Result result1;
            // 如果删除失败，返回用户不存在,无法删除
            if (!result) {
                result1 = new Result("用户不存在,无法删除", Code.DELETE_FAIL, false);
            } else {
                // 如果删除成功，返回删除成功
                result1 = new Result("删除成功", Code.DELETE_SUCCESS);
            }
            // 返回结果
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @PostMapping("/update")
    public ResponseEntity<Result> updateUser(@RequestBody User userValue) {
        try {
            // 根据用户值更新用户信息
            User user = rootService.updateUser(userValue);
            Result result;
            if (user == null) {
                // 如果用户列表为空，返回一个错误或空的结果
                result = new Result("已经有此用户不存在,无法更改", Code.UPDATE_FAIL);
            } else {
                // 如果用户列表不为空，返回成功的结果，并包含用户列表数据
                result = new Result("更改用户成功", Code.UPDATE_SUCCESS, user);
            }
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            // 捕获异常，并抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    // 获取指定页码和每页显示记录数
    @GetMapping("/{pageNumber}/{pageSize}")
    public ResponseEntity<Result> pageUser(@PathVariable Integer pageNumber, @PathVariable Integer pageSize) {
        // 调用rootService的pageUser方法，传入页码和每页显示记录数
        try {
            boolean result = rootService.pageUser(pageNumber, pageSize);
            // 创建Result对象
            Result result1;

            // 如果查询失败
            if (!result) {
                // 返回用户不存在的错误信息
                result1 = new Result("用户不存在,无法分页查询", Code.PAGESELECT_FAIL, false);
            } else {
                // 否则返回分页查询成功的信息
                result1 = new Result("分页查询成功", Code.PAGESELECT_SUCCESS);
            }
            // 返回ResponseEntity对象，包含查询结果
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    // 根据id1和id2的值进行排序
    @PostMapping("/{id1}/{id2}")
    public ResponseEntity<Result> sortById(@PathVariable Integer id1, @PathVariable Integer id2) {
        try {
            // 调用rootService的sortById方法，传入id1和id2，判断返回值是否为true
            boolean result = rootService.sortById(id1, id2);
            // 创建一个Result对象
            Result result1;
            // 如果返回值为false，则表示用户不存在，无法进行排序
            if (!result) {
                result1 = new Result("用户不存在,无法进行排序", Code.SORT_FAIL, false);
            } else {
                // 如果返回值为true，则表示排序成功
                result1 = new Result("排序成功", Code.SORT_SUCCESS);
            }
            // 返回ResponseEntity对象，其中包含result1
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @PostMapping("/{name1}/{name2}")
    public ResponseEntity<Result> sortByName(@PathVariable String name1, @PathVariable String name2) {
        // 根据name1和name2进行排序
        try {
            boolean result = rootService.sortByName(name1, name2);
            Result result1;
            // 如果排序失败，返回用户不存在的错误信息
            if (!result) {
                result1 = new Result("用户不存在,无法进行排序", Code.SORT_FAIL, false);
            } else {
                // 如果排序成功，返回排序成功的信息
                result1 = new Result("排序成功", Code.SORT_SUCCESS);
            }
            // 返回排序结果
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 捕获异常，抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @PostMapping("/{phoneNumber1}/{phoneNumber2}")
    public ResponseEntity<Result> sortByPhoneNumber(@PathVariable String phoneNumber1, @PathVariable String phoneNumber2) {
        // 根据手机号1和手机号2进行排序
        try {
            boolean result = rootService.sortByPhoneNumber(phoneNumber1, phoneNumber2);
            Result result1;
            // 如果排序失败
            if (!result) {
                result1 = new Result("用户不存在,无法进行排序", Code.SORT_FAIL, false);
            } else {
                // 如果排序成功
                result1 = new Result("排序成功", Code.SORT_SUCCESS);
            }
            // 返回排序结果
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @PostMapping("/{email1}/{email2}")
    public ResponseEntity<Result> sortByEmail(@PathVariable String email1, @PathVariable String email2) {
        // 根据email1和email2对用户进行排序
        try {
            boolean result = rootService.sortByEmail(email1, email2);
            Result result1;
            // 如果排序失败，返回用户不存在的错误信息
            if (!result) {
                result1 = new Result("用户不存在,无法进行排序", Code.SORT_FAIL, false);
            } else {
                // 如果排序成功，返回排序成功的信息
                result1 = new Result("排序成功", Code.SORT_SUCCESS);
            }
            // 返回排序结果
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 捕获异常，抛出运行时异常
            throw new RuntimeException(e);
        }
    }
}